תכנות-על (Metaprogramming) ב-TypeScript: שיקוף ויצירת קוד

תכנות-על, אומנות כתיבת קוד שמבצע מניפולציות על קוד אחר, פותח אפשרויות מרגשות ב-TypeScript. פוסט זה מתעמק בתחום התכנות-על באמצעות שיקוף וטכניקות יצירת קוד, וחוקר כיצד ניתן לנתח ולשנות את הקוד שלך במהלך הידור. נבחן כלים רבי עוצמה כמו דקורטורים ו-API של מהדר TypeScript, שיעצימו אותך לבנות יישומים חזקים, ניתנים להרחבה ובעלי תחזוקה גבוהה.

מהו תכנות-על?

ביסודו, תכנות-על כולל כתיבת קוד הפועל על קוד אחר. זה מאפשר לך ליצור, לנתח או לשנות קוד באופן דינמי בזמן קומפילציה או בזמן ריצה. ב-TypeScript, תכנות-על מתמקד בעיקר בפעולות בזמן קומפילציה, תוך ניצול מערכת הטיפוסים והמהדר עצמו כדי להשיג אבסטרקציות חזקות.

בהשוואה לגישות לתכנות-על בזמן ריצה שנמצאות בשפות כמו Python או Ruby, הגישה בזמן קומפילציה של TypeScript מציעה יתרונות כמו:

• בטיחות טיפוסים: שגיאות נתפסות במהלך קומפילציה, ומונעות התנהגות בלתי צפויה בזמן ריצה.
• ביצועים: יצירת קוד ומניפולציה מתרחשים לפני זמן ריצה, וכתוצאה מכך ביצוע קוד אופטימלי.
• Intellisense והשלמה אוטומטית: מבני תכנות-על יכולים להיות מובנים על ידי שירות שפת TypeScript, ומספקים תמיכה טובה יותר בכלים למפתחים.

שיקוף ב-TypeScript

שיקוף, בהקשר של תכנות-על, הוא היכולת של תוכנית לבחון ולשנות את המבנה וההתנהגות שלה עצמה. ב-TypeScript, זה כרוך בעיקר בבחינת טיפוסים, מחלקות, מאפיינים ושיטות בזמן קומפילציה. אמנם ל-TypeScript אין מערכת שיקוף בזמן ריצה מסורתית כמו Java או .NET, אך אנו יכולים למנף את מערכת הטיפוסים והדקורטורים כדי להשיג השפעות דומות.

דקורטורים: הערות לתכנות-על

דקורטורים הם תכונה רבת עוצמה ב-TypeScript המספקת דרך להוסיף הערות ולשנות את ההתנהגות של מחלקות, שיטות, מאפיינים ופרמטרים. הם פועלים ככלים לתכנות-על בזמן קומפילציה, המאפשרים לך להזרים היגיון ומטא-נתונים מותאמים אישית לקוד שלך.

דקורטורים מוכרזים באמצעות הסמל @ ואחריו שם הדקורטור. ניתן להשתמש בהם כדי:

• להוסיף מטא-נתונים למחלקות או לאיברים.
• לשנות הגדרות מחלקה.
• לעטוף או להחליף שיטות.
• לרשום מחלקות או שיטות עם רישום מרכזי.

דוגמה: דקורטור רישום

בואו ניצור דקורטור פשוט שרושם קריאות לשיטות:

            
function logMethod(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function (...args: any[]) {
    console.log(`Calling method ${propertyKey} with arguments: ${JSON.stringify(args)}`);
    const result = originalMethod.apply(this, args);
    console.log(`Method ${propertyKey} returned: ${result}`);
    return result;
  };

  return descriptor;
}

class MyClass {
  @logMethod
  add(x: number, y: number): number {
    return x + y;
  }
}

const myInstance = new MyClass();
myInstance.add(5, 3);

            

              
                Copy
              
            
          

בדוגמה זו, הדקורטור @logMethod מיירט קריאות לשיטה add, רושם את הארגומנטים ואת ערך ההחזרה, ולאחר מכן מבצע את השיטה המקורית. זה מדגים כיצד ניתן להשתמש בדקורטורים כדי להוסיף דאגות חוצות כמו רישום או ניטור ביצועים מבלי לשנות את ההיגיון המרכזי של המחלקה.

מפעלי דקורטורים

מפעלי דקורטורים מאפשרים לך ליצור דקורטורים פרמטריים, מה שהופך אותם לגמישים וניתנים לשימוש חוזר יותר. מפעל דקורטורים הוא פונקציה שמחזירה דקורטור.

            
function logMethodWithPrefix(prefix: string) {
  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value;

    descriptor.value = function (...args: any[]) {
      console.log(`${prefix} - Calling method ${propertyKey} with arguments: ${JSON.stringify(args)}`);
      const result = originalMethod.apply(this, args);
      console.log(`${prefix} - Method ${propertyKey} returned: ${result}`);
      return result;
    };

    return descriptor;
  };
}

class MyClass {
  @logMethodWithPrefix("DEBUG")
  add(x: number, y: number): number {
    return x + y;
  }
}

const myInstance = new MyClass();
myInstance.add(5, 3);

            

              
                Copy
              
            
          

בדוגמה זו, logMethodWithPrefix הוא מפעל דקורטורים שלוקח קידומת כארגומנט. הדקורטור המוחזר רושם קריאות לשיטות עם הקידומת שצוינה. זה מאפשר לך להתאים אישית את התנהגות הרישום בהתבסס על ההקשר.

שיקוף מטא-נתונים עם `reflect-metadata`

הספרייה reflect-metadata מספקת דרך סטנדרטית לאחסן ולאחזר מטא-נתונים המשויכים למחלקות, שיטות, מאפיינים ופרמטרים. היא משלימה דקורטורים על ידי כך שהיא מאפשרת לך לצרף נתונים שרירותיים לקוד שלך ולגשת אליהם בזמן ריצה (או בזמן קומפילציה באמצעות הצהרות טיפוסים).

כדי להשתמש ב-reflect-metadata, עליך להתקין אותה:

            
npm install reflect-metadata --save

            

              
                Copy
              
            
          

וכן להפעיל את האפשרות emitDecoratorMetadata של המהדר בקובץ tsconfig.json שלך:

            
{
  "compilerOptions": {
    "emitDecoratorMetadata": true
  }
}

            

              
                Copy
              
            
          

דוגמה: אימות מאפיינים

בואו ניצור דקורטור שמאמת ערכי מאפיינים בהתבסס על מטא-נתונים:

            
import 'reflect-metadata';

const requiredMetadataKey = Symbol("required");

function required(target: Object, propertyKey: string | symbol, parameterIndex: number) {
  let existingRequiredParameters: number[] = Reflect.getOwnMetadata(requiredMetadataKey, target, propertyKey) || [];
  existingRequiredParameters.push(parameterIndex);
  Reflect.defineMetadata(requiredMetadataKey, existingRequiredParameters, target, propertyKey);
}

function validate(target: any, propertyName: string, descriptor: TypedPropertyDescriptor) {
  let method = descriptor.value!;

  descriptor.value = function () {
    let requiredParameters: number[] = Reflect.getOwnMetadata(requiredMetadataKey, target, propertyName);
    if (requiredParameters) {
      for (let parameterIndex of requiredParameters) {
        if (arguments.length <= parameterIndex || arguments[parameterIndex] === undefined) {
          throw new Error("Missing required argument.");
        }
      }
    }
    return method.apply(this, arguments);
  };
}

class MyClass {
  myMethod(@required param1: string, param2: number) {
    console.log(param1, param2);
  }
}

            

              
                Copy
              
            
          

בדוגמה זו, הדקורטור @required מסמן פרמטרים כנדרשים. הדקורטור validate מיירט קריאות לשיטות ובודק אם כל הפרמטרים הנדרשים קיימים. אם חסר פרמטר נדרש, נזרקת שגיאה. זה מדגים כיצד ניתן להשתמש ב-reflect-metadata כדי לאכוף כללי אימות המבוססים על מטא-נתונים.

יצירת קוד עם ה-API של מהדר TypeScript

ה-API של מהדר TypeScript מספק גישה תכנותית למהדר TypeScript, המאפשרת לך לנתח, לשנות וליצור קוד TypeScript. זה פותח אפשרויות רבות עוצמה לתכנות-על, ומאפשר לך לבנות מחוללי קוד מותאמים אישית, לינטרים וכלים אחרים לפיתוח.

הבנת עץ התחביר המופשט (AST)

הבסיס ליצירת קוד עם ה-API של המהדר הוא עץ התחביר המופשט (AST). ה-AST הוא ייצוג דמוי עץ של קוד TypeScript שלך, כאשר כל צומת בעץ מייצג רכיב תחבירי, כגון מחלקה, פונקציה, משתנה או ביטוי.

ה-API של המהדר מספק פונקציות לטיפול ב-AST ולמניפולציה שלו, ומאפשר לך לנתח ולשנות את מבנה הקוד שלך. אתה יכול להשתמש ב-AST כדי:

• לשלוף מידע על הקוד שלך (לדוגמה, למצוא את כל המחלקות שמיישמות ממשק ספציפי).
• לשנות את הקוד שלך (לדוגמה, ליצור אוטומטית הערות תיעוד).
• ליצור קוד חדש (לדוגמה, ליצור קוד תקני לאובייקטי גישה לנתונים).

שלבים ליצירת קוד

זרימת העבודה האופיינית ליצירת קוד עם ה-API של המהדר כוללת את השלבים הבאים:

1. ניתוח קוד TypeScript: השתמש בפונקציה ts.createSourceFile כדי ליצור אובייקט SourceFile, המייצג את קוד TypeScript המנותח.
2. טיפול ב-AST: השתמש בפונקציות ts.visitNode ו-ts.visitEachChild כדי לעבור רקורסיבית על ה-AST ולמצוא את הצמתים שמעניינים אותך.
3. שינוי ה-AST: צור צמתי AST חדשים או שנה צמתים קיימים כדי ליישם את השינויים הרצויים שלך.
4. יצירת קוד TypeScript: השתמש בפונקציה ts.createPrinter כדי ליצור קוד TypeScript מה-AST ששוּנה.

דוגמה: יצירת אובייקט העברת נתונים (DTO)

בואו ניצור מחולל קוד פשוט שיוצר ממשק אובייקט העברת נתונים (DTO) בהתבסס על הגדרת מחלקה.

            
import * as ts from "typescript";
import * as fs from "fs";

function generateDTO(sourceFile: ts.SourceFile, className: string): string | undefined {
  let interfaceName = className + "DTO";
  let properties: string[] = [];

  function visit(node: ts.Node) {
    if (ts.isClassDeclaration(node) && node.name?.text === className) {
      node.members.forEach(member => {
        if (ts.isPropertyDeclaration(member) && member.name) {
          let propertyName = member.name.getText(sourceFile);
          let typeName = "any"; // Default type

          if (member.type) {
            typeName = member.type.getText(sourceFile);
          }

          properties.push(`  ${propertyName}: ${typeName};`);
        }
      });
    }
  }

ts.visitNode(sourceFile, visit);

  if (properties.length > 0) {
    return `interface ${interfaceName} {\n${properties.join("\n")}\n}`;
  }

  return undefined;
}

// Example Usage
const fileName = "./src/my_class.ts"; // Replace with your file path
const classNameToGenerateDTO = "MyClass";

fs.readFile(fileName, (err, buffer) => {
  if (err) {
    console.error("Error reading file:", err);
    return;
  }

  const sourceCode = buffer.toString();

  const sourceFile = ts.createSourceFile(
    fileName,
    sourceCode,
    ts.ScriptTarget.ES2015,
    true
  );

  const dtoInterface = generateDTO(sourceFile, classNameToGenerateDTO);

  if (dtoInterface) {
    console.log(dtoInterface);
  } else {
    console.log(`Class ${classNameToGenerateDTO} not found or no properties to generate DTO from.`);
  }
});

            

              
                Copy
              
            
          

my_class.ts:

            
class MyClass {
  name: string;
  age: number;
  isActive: boolean;
}

            

              
                Copy
              
            
          

דוגמה זו קוראת קובץ TypeScript, מוצאת מחלקה עם השם שצוין, מחלצת את המאפיינים שלה ואת הטיפוסים שלהם, ויוצרת ממשק DTO עם אותם מאפיינים. הפלט יהיה:

            
interface MyClassDTO {
  name: string;
  age: number;
  isActive: boolean;
}

            

              
                Copy
              
            
          

הסבר:

• הוא קורא את קוד המקור של קובץ TypeScript באמצעות fs.readFile.
• הוא יוצר ts.SourceFile מקוד המקור באמצעות ts.createSourceFile, המייצג את הקוד המנותח.
• הפונקציה generateDTO מבקרת ב-AST. אם נמצאה הצהרת מחלקה עם השם שצוין, היא עוברת על האיברים של המחלקה.
• עבור כל הצהרת מאפיין, הוא מחלץ את שם המאפיין והטיפוס שלו ומוסיף אותו למערך properties.
• לבסוף, הוא בונה את מחרוזת ממשק ה-DTO באמצעות המאפיינים המופקים ומחזיר אותה.

יישומים מעשיים של יצירת קוד

ליצירת קוד עם ה-API של המהדר יש יישומים מעשיים רבים, כולל:

• יצירת קוד תקני: יצירה אוטומטית של קוד לאובייקטי גישה לנתונים, לקוחות API או משימות חוזרות אחרות.
• יצירת לינטרים מותאמים אישית: אכיפת תקני קידוד ושיטות עבודה מומלצות על ידי ניתוח ה-AST וזיהוי בעיות פוטנציאליות.
• יצירת תיעוד: שלוף מידע מה-AST כדי ליצור תיעוד API.
• אוטומציה של שינוי מבנה: שנה אוטומטית את הקוד על ידי שינוי ה-AST.
• בניית שפות ספציפיות לתחום (DSLs): צור שפות מותאמות לתחומים ספציפיים וצור קוד TypeScript מהן.

טכניקות תכנות-על מתקדמות

מלבד דקורטורים וה-API של המהדר, ניתן להשתמש במספר טכניקות אחרות לתכנות-על ב-TypeScript:

• טיפוסי תנאי: השתמש בטיפוסי תנאי כדי להגדיר טיפוסים המבוססים על טיפוסים אחרים, המאפשרים לך ליצור הגדרות טיפוסים גמישות וניתנות להתאמה. לדוגמה, אתה יכול ליצור טיפוס שמחלץ את סוג ההחזרה של פונקציה.
• טיפוסים ממופים: שנה טיפוסים קיימים על ידי מיפוי על המאפיינים שלהם, המאפשר לך ליצור טיפוסים חדשים עם טיפוסי מאפיינים או שמות ששונו. לדוגמה, צור טיפוס שהופך את כל המאפיינים של טיפוס אחר לקריאה בלבד.
• הסקת טיפוסים: למנף את יכולות הסקת הטיפוסים של TypeScript כדי להסיק אוטומטית טיפוסים המבוססים על הקוד, תוך הפחתת הצורך בהערות טיפוס מפורשות.
• טיפוסי מחרוזת מילולית של תבנית: השתמש בטיפוסי מחרוזת מילולית של תבנית כדי ליצור טיפוסים מבוססי מחרוזת שניתן להשתמש בהם ליצירת קוד או לאימות. לדוגמה, יצירת מפתחות ספציפיים בהתבסס על קבועים אחרים.

היתרונות של תכנות-על

תכנות-על מציע מספר יתרונות בפיתוח TypeScript:

• שימוש חוזר בקוד מוגבר: צור רכיבים ומופשטים שמישים חוזרת שניתן ליישם על חלקים מרובים של היישום שלך.
• קוד תקני מופחת: צור אוטומטית קוד חוזר, תוך הפחתת כמות הקידוד הידני הנדרשת.
• שיפור תחזוקת הקוד: הפוך את הקוד שלך למודולרי יותר וקל יותר להבנה על ידי הפרדת דאגות ושימוש בתכנות-על לטיפול בדאגות חוצות.
• בטיחות טיפוסים משופרת: תפוס שגיאות במהלך קומפילציה, ומונע התנהגות בלתי צפויה בזמן ריצה.
• פרודוקטיביות מוגברת: הפוך משימות לאוטומטיות וייעל את זרימות העבודה של הפיתוח, מה שמוביל לפרודוקטיביות מוגברת.

אתגרים בתכנות-על

בעוד שתכנות-על מציע יתרונות משמעותיים, הוא גם מציג כמה אתגרים:

• מורכבות מוגברת: תכנות-על יכול להפוך את הקוד שלך למורכב יותר וקשה יותר להבנה, במיוחד עבור מפתחים שאינם מכירים את הטכניקות המעורבות.
• קשיי ניפוי שגיאות: ניפוי שגיאות בקוד תכנות-על יכול להיות מאתגר יותר מאשר ניפוי שגיאות בקוד מסורתי, מכיוון שהקוד שמבוצע עשוי שלא להיות גלוי ישירות בקוד המקור.
• תקורה של ביצועים: יצירת קוד ומניפולציה יכולים להכניס תקורה של ביצועים, במיוחד אם לא נעשה בזהירות.
• עקומת למידה: שליטה בטכניקות תכנות-על דורשת השקעה משמעותית של זמן ומאמץ.

סיכום

תכנות-על ב-TypeScript, באמצעות שיקוף ויצירת קוד, מציע כלים רבי עוצמה לבניית יישומים חזקים, ניתנים להרחבה ובעלי תחזוקה גבוהה. על ידי מינוף דקורטורים, ה-API של מהדר TypeScript ותכונות מערכת טיפוסים מתקדמות, אתה יכול לבצע משימות אוטומטיות, להפחית קוד תקני ולשפר את האיכות הכוללת של הקוד שלך. בעוד שתכנות-על מציג כמה אתגרים, היתרונות שהוא מציע הופכים אותו לטכניקה בעלת ערך עבור מפתחי TypeScript מנוסים.

אמצו את הכוח של תכנות-על ופתחו אפשרויות חדשות בפרויקטי ה-TypeScript שלכם. חקור את הדוגמאות שסופקו, התנסה בטכניקות שונות וגלה כיצד תכנות-על יכול לעזור לך לבנות תוכנה טובה יותר.